home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gsropt.h < prev    next >
C/C++ Source or Header  |  1996-12-07  |  7KB  |  190 lines
  1. /* Copyright (C) 1995, 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gsropt.h */
  20. /* RasterOp / transparency / render algorithm type definitions */
  21.  
  22. #ifndef gsropt_INCLUDED
  23. #  define gsropt_INCLUDED
  24.  
  25. /*
  26.  * This file defines the types for some library extensions that are
  27.  * motivated by PCL5 and also made available for PostScript:
  28.  * RasterOp, source and pattern white-pixel transparency, and
  29.  * per-pixel "render algorithm" information.
  30.  */
  31.  
  32. /*
  33.  * By the magic of Boolean algebra, we can operate on the rop codes using
  34.  * Boolean operators and get the right result.  E.g., the value of
  35.  * (rop3_S & rop3_D) is the rop3 code for S & D.  We just have to remember
  36.  * to mask results with rop2_1 or rop3_1 if necessary.
  37.  */
  38.  
  39. /* 2-input RasterOp */
  40. typedef enum {
  41.     rop2_0 = 0,
  42.     rop2_S = 0xc,        /* source */
  43. #define rop2_S_shift 2
  44.     rop2_D = 0xa,        /* destination */
  45. #define rop2_D_shift 1
  46.     rop2_1 = 0xf,
  47. #define rop2_operand(shift, d, s)\
  48.   ((shift) == 2 ? (s) : (d))
  49.     rop2_default = rop2_S
  50. } gs_rop2_t;
  51.  
  52. /*
  53.  * For the 3-input case, we follow H-P's inconsistent terminology:
  54.  * the transparency mode is called pattern transparency, but the third
  55.  * RasterOp operand is called texture, not pattern.
  56.  */
  57.  
  58. /* 3-input RasterOp */
  59. typedef enum {
  60.     rop3_0 = 0,
  61.     rop3_T = 0xf0,        /* texture */
  62. #define rop3_T_shift 4
  63.     rop3_S = 0xcc,        /* source */
  64. #define rop3_S_shift 2
  65.     rop3_D = 0xaa,        /* destination */
  66. #define rop3_D_shift 1
  67.     rop3_1 = 0xff,
  68.     rop3_default = rop3_T | rop3_S
  69. } gs_rop3_t;
  70.  
  71. /* All the transformations on rop3s are designed so that */
  72. /* they can also be used on lops.  The only place this costs anything */
  73. /* is in rop3_invert. */
  74.  
  75. /*
  76.  * Invert an operand.
  77.  */
  78. #define rop3_invert_(op, mask, shift)\
  79.   ( (((op) & mask) >> shift) | (((op) & (rop3_1 - mask)) << shift) |\
  80.     ((op) & ~rop3_1) )
  81. #define rop3_invert_D(op) rop3_invert_(op, rop3_D, rop3_D_shift)
  82. #define rop3_invert_S(op) rop3_invert_(op, rop3_S, rop3_S_shift)
  83. #define rop3_invert_T(op) rop3_invert_(op, rop3_T, rop3_T_shift)
  84. /*
  85.  * Pin an operand to 0.
  86.  */
  87. #define rop3_know_0_(op, mask, shift)\
  88.   ( (((op) & (rop3_1 - mask)) << shift) | ((op) & ~mask) )
  89. #define rop3_know_D_0(op) rop3_know_0_(op, rop3_D, rop3_D_shift)
  90. #define rop3_know_S_0(op) rop3_know_0_(op, rop3_S, rop3_S_shift)
  91. #define rop3_know_T_0(op) rop3_know_0_(op, rop3_T, rop3_T_shift)
  92. /*
  93.  * Pin an operand to 1.
  94.  */
  95. #define rop3_know_1_(op, mask, shift)\
  96.   ( (((op) & mask) >> shift) | ((op) & ~(rop3_1 - mask)) )
  97. #define rop3_know_D_1(op) rop3_know_1_(op, rop3_D, rop3_D_shift)
  98. #define rop3_know_S_1(op) rop3_know_1_(op, rop3_S, rop3_S_shift)
  99. #define rop3_know_T_1(op) rop3_know_1_(op, rop3_T, rop3_T_shift)
  100. /*
  101.  * Swap S and T.
  102.  */
  103. #define rop3_swap_S_T(op)\
  104.   ( (((op) & rop3_S & ~rop3_T) << (rop3_T_shift - rop3_S_shift)) |\
  105.     (((op) & ~rop3_S & rop3_T) >> (rop3_T_shift - rop3_S_shift)) |\
  106.     ((op) & (~rop3_1 | (rop3_S ^ rop3_T))) )
  107. /*
  108.  * Account for transparency.
  109.  */
  110. #define rop3_use_D_when_0_(op, mask)\
  111.   (((op) & ~(rop3_1 - mask)) | (rop3_D & ~mask))
  112. #define rop3_use_D_when_1_(op, mask)\
  113.   (((op) & ~mask) | (rop3_D & mask))
  114. #define rop3_use_D_when_S_0(op) rop3_use_D_when_0_(op, rop3_S)
  115. #define rop3_use_D_when_S_1(op) rop3_use_D_when_1_(op, rop3_S)
  116. #define rop3_use_D_when_T_0(op) rop3_use_D_when_0_(op, rop3_T)
  117. #define rop3_use_D_when_T_1(op) rop3_use_D_when_1_(op, rop3_T)
  118. /*
  119.  * Invert the result.
  120.  */
  121. #define rop3_not(op) ((op) ^ rop3_1)
  122. /*
  123.  * Test whether an operand is used.
  124.  */
  125. #define rop3_uses_(op, mask, shift)\
  126.   ( ((((op) << shift) ^ (op)) & mask) != 0 )
  127. #define rop3_uses_D(op) rop3_uses_(op, rop3_D, rop3_D_shift)
  128. #define rop3_uses_S(op) rop3_uses_(op, rop3_S, rop3_S_shift)
  129. #define rop3_uses_T(op) rop3_uses_(op, rop3_T, rop3_T_shift)
  130. /*
  131.  * Test whether an operation is idempotent, i.e., whether
  132.  * f(D, S, T) = f(f(D, S, T), S, T).  This is equivalent to the condition that
  133.  * for all values s and t, !( f(0,s,t) == 1 && f(1,s,t) == 0 ).
  134.  */
  135. #define rop3_is_idempotent(op)\
  136.   !( (op) & ~((op) << rop3_D_shift) & rop3_D )
  137.  
  138. /* Transparency */
  139. #define source_transparent_default false
  140. #define pattern_transparent_default false
  141.  
  142. /* Render algorithm */
  143. #define render_algorithm_default 0
  144. #define render_algorithm_min 0
  145. #define render_algorithm_max 14
  146.  
  147. /*
  148.  * We define a logical operation as a RasterOp, transparency flags,
  149.  * and render algorithm all packed into a single integer.
  150.  * In principle, we should use a structure, but most C implementations
  151.  * implement structure values very inefficiently.
  152.  */
  153. #define lop_rop(lop) ((gs_rop3_t)((lop) & 0xff))  /* must be low-order bits */
  154. #define lop_S_transparent 0x100
  155. #define lop_T_transparent 0x200
  156. #define lop_ral_shift 10
  157. #define lop_ral_mask 0xf
  158. typedef uint gs_logical_operation_t;
  159. #define lop_default\
  160.   (rop3_default |\
  161.    (source_transparent_default ? lop_S_transparent : 0) |\
  162.    (pattern_transparent_default ? lop_T_transparent : 0) |\
  163.    (render_algorithm_default << lop_ral_shift))
  164.  
  165. /* Test whether a logical operation just sets D = x if y = 0. */
  166. #define lop_no_T_is_S(lop)\
  167.   (((lop) & (lop_S_transparent | (rop3_1 - rop3_T))) == (rop3_S & ~rop3_T))
  168. #define lop_no_S_is_T(lop)\
  169.   (((lop) & (lop_T_transparent | (rop3_1 - rop3_S))) == (rop3_T & ~rop3_S))
  170. /* Test whether a logical operation is idempotent. */
  171. #define lop_is_idempotent(lop) rop3_is_idempotent(lop)
  172.  
  173. /* Define the interface to the table of 256 RasterOp procedures. */
  174. typedef unsigned rop_operand;
  175. typedef rop_operand (*rop_proc)(P3(rop_operand D, rop_operand S, rop_operand T));
  176.  
  177. /* Define the table of operand usage by the 256 RasterOp operations. */
  178. typedef enum {
  179.   rop_usage_none = 0,
  180.   rop_usage_D = 1,
  181.   rop_usage_S = 2,
  182.   rop_usage_DS = 3,
  183.   rop_usage_T = 4,
  184.   rop_usage_DT = 5,
  185.   rop_usage_ST = 6,
  186.   rop_usage_DST = 7
  187. } rop_usage_t;
  188.  
  189. #endif                    /* gsropt_INCLUDED */
  190.